home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2000 / MacHack 2000.toast / pc / The Hacks / MacHacksBug / Python 1.5.2c1 / Mac / Lib / preferences.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2000-06-23  |  11.5 KB  |  287 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 1.5)
  3.  
  4. import Res
  5. import macfs
  6. import struct
  7. import MACFS
  8. READ = 1
  9. READWRITE = 3
  10. Error = 'Preferences.Error'
  11. debug = 0
  12.  
  13. class NullLoader:
  14.     
  15.     def __init__(self, data = None):
  16.         self.data = data
  17.  
  18.     
  19.     def load(self):
  20.         if self.data is None:
  21.             raise Error, 'No default given'
  22.         
  23.         return self.data
  24.  
  25.     
  26.     def save(self, data):
  27.         raise Error, 'Cannot save to default value'
  28.  
  29.     
  30.     def delete(self, deep = 0):
  31.         if debug:
  32.             print 'Attempt to delete default value'
  33.         
  34.         raise Error, 'Cannot delete default value'
  35.  
  36.  
  37. _defaultdefault = NullLoader()
  38.  
  39. class ResLoader:
  40.     
  41.     def __init__(self, filename, resid, resnum = None, resname = None, default = _defaultdefault):
  42.         self.filename = filename
  43.         self.fss = macfs.FSSpec(self.filename)
  44.         self.resid = resid
  45.         self.resnum = resnum
  46.         self.resname = resname
  47.         self.default = default
  48.         self.data = None
  49.  
  50.     
  51.     def load(self):
  52.         oldrh = Res.CurResFile()
  53.         
  54.         try:
  55.             rh = Res.FSpOpenResFile(self.fss, READ)
  56.         except Res.Error:
  57.             self.data = self.default.load()
  58.             return self.data
  59.  
  60.         
  61.         try:
  62.             if self.resname:
  63.                 handle = Res.Get1NamedResource(self.resid, self.resname)
  64.             else:
  65.                 handle = Res.Get1Resource(self.resid, self.resnum)
  66.         except Res.Error:
  67.             self.data = self.default.load()
  68.  
  69.         if debug:
  70.             print 'Loaded', (self.resid, self.resnum, self.resname), 'from', self.fss.as_pathname()
  71.         
  72.         self.data = handle.data
  73.         Res.CloseResFile(rh)
  74.         Res.UseResFile(oldrh)
  75.         return self.data
  76.  
  77.     
  78.     def save(self, data):
  79.         if self.data is None or self.data != data:
  80.             oldrh = Res.CurResFile()
  81.             rh = Res.FSpOpenResFile(self.fss, READWRITE)
  82.             
  83.             try:
  84.                 handle = Res.Get1Resource(self.resid, self.resnum)
  85.             except Res.Error:
  86.                 handle = Res.Resource(data)
  87.                 handle.AddResource(self.resid, self.resnum, '')
  88.                 if debug:
  89.                     print 'Added', (self.resid, self.resnum), 'to', self.fss.as_pathname()
  90.                 
  91.             except:
  92.                 debug
  93.  
  94.             handle.data = data
  95.             handle.ChangedResource()
  96.             if debug:
  97.                 print 'Changed', (self.resid, self.resnum), 'in', self.fss.as_pathname()
  98.             
  99.             Res.CloseResFile(rh)
  100.             Res.UseResFile(oldrh)
  101.         
  102.  
  103.     
  104.     def delete(self, deep = 0):
  105.         if debug:
  106.             print 'Deleting in', self.fss.as_pathname(), `self.data`, deep
  107.         
  108.         oldrh = Res.CurResFile()
  109.         rh = Res.FSpOpenResFile(self.fss, READWRITE)
  110.         
  111.         try:
  112.             handle = Res.Get1Resource(self.resid, self.resnum)
  113.         except Res.Error:
  114.             if deep:
  115.                 if debug:
  116.                     print 'deep in', self.default
  117.                 
  118.                 self.default.delete(1)
  119.             
  120.         except:
  121.             deep
  122.  
  123.         handle.RemoveResource()
  124.         if debug:
  125.             print 'Deleted', (self.resid, self.resnum), 'from', self.fss.as_pathname()
  126.         
  127.         self.data = None
  128.         Res.CloseResFile(rh)
  129.         Res.UseResFile(oldrh)
  130.  
  131.  
  132.  
  133. class AnyResLoader:
  134.     
  135.     def __init__(self, resid, resnum = None, resname = None, default = _defaultdefault):
  136.         self.resid = resid
  137.         self.resnum = resnum
  138.         self.resname = resname
  139.         self.default = default
  140.         self.data = None
  141.  
  142.     
  143.     def load(self):
  144.         
  145.         try:
  146.             if self.resname:
  147.                 handle = Res.GetNamedResource(self.resid, self.resname)
  148.             else:
  149.                 handle = Res.GetResource(self.resid, self.resnum)
  150.         except Res.Error:
  151.             self.data = self.default.load()
  152.  
  153.         self.data = handle.data
  154.         return self.data
  155.  
  156.     
  157.     def save(self, data):
  158.         raise Error, 'Cannot save AnyResLoader preferences'
  159.  
  160.     
  161.     def delete(self, deep = 0):
  162.         raise Error, 'Cannot delete AnyResLoader preferences'
  163.  
  164.  
  165.  
  166. class StructLoader:
  167.     
  168.     def __init__(self, format, loader):
  169.         self.format = format
  170.         self.loader = loader
  171.  
  172.     
  173.     def load(self):
  174.         data = self.loader.load()
  175.         return struct.unpack(self.format, data)
  176.  
  177.     
  178.     def save(self, data):
  179.         data = apply(struct.pack, (self.format,) + data)
  180.         self.loader.save(data)
  181.  
  182.     
  183.     def delete(self, deep = 0):
  184.         self.loader.delete(deep)
  185.  
  186.  
  187.  
  188. class PstringLoader:
  189.     
  190.     def __init__(self, loader):
  191.         self.loader = loader
  192.  
  193.     
  194.     def load(self):
  195.         data = self.loader.load()
  196.         len = ord(data[0])
  197.         return data[1:1 + len]
  198.  
  199.     
  200.     def save(self, data):
  201.         if len(data) > 255:
  202.             raise Error, 'String too big for pascal-style'
  203.         
  204.         self.loader.save(chr(len(data)) + data)
  205.  
  206.     
  207.     def delete(self, deep = 0):
  208.         self.loader.delete(deep)
  209.  
  210.  
  211.  
  212. class VersionLoader(StructLoader):
  213.     
  214.     def load(self):
  215.         while 1:
  216.             data = self.loader.load()
  217.             if debug:
  218.                 print 'Versionloader:', `data`
  219.             
  220.             
  221.             try:
  222.                 rv = struct.unpack(self.format, data)
  223.                 rv = self.versioncheck(rv)
  224.                 return rv
  225.             except (struct.error, Error):
  226.                 self.delete(1)
  227.  
  228.  
  229.     
  230.     def versioncheck(self, data):
  231.         return data
  232.  
  233.  
  234.  
  235. class StrListLoader:
  236.     
  237.     def __init__(self, loader):
  238.         self.loader = loader
  239.  
  240.     
  241.     def load(self):
  242.         data = self.loader.load()
  243.         (num,) = struct.unpack('h', data[:2])
  244.         data = data[2:]
  245.         rv = []
  246.         for i in range(num):
  247.             strlen = ord(data[0])
  248.             str = data[1:strlen + 1]
  249.             data = data[strlen + 1:]
  250.             rv.append(str)
  251.         
  252.         return rv
  253.  
  254.     
  255.     def save(self, list):
  256.         rv = struct.pack('h', len(list))
  257.         for str in list:
  258.             rv = rv + chr(len(str)) + str
  259.         
  260.         self.loader.save(rv)
  261.  
  262.     
  263.     def delete(self, deep = 0):
  264.         self.loader.delete(deep)
  265.  
  266.  
  267.  
  268. def preferencefile(filename, creator = None, type = None):
  269.     if creator != None:
  270.         pass
  271.     create = type != None
  272.     (vrefnum, dirid) = macfs.FindFolder(MACFS.kOnSystemDisk, 'pref', create)
  273.     fss = macfs.FSSpec((vrefnum, dirid, ':Python:' + filename))
  274.     oldrf = Res.CurResFile()
  275.     if create:
  276.         
  277.         try:
  278.             rh = Res.FSpOpenResFile(fss, READ)
  279.         except Res.Error:
  280.             Res.FSpCreateResFile(fss, creator, type, MACFS.smAllScripts)
  281.  
  282.         Res.CloseResFile(rh)
  283.         Res.UseResFile(oldrf)
  284.     
  285.     return fss
  286.  
  287.